type math/big.nat

250 uses

	math/big (current package)
		decimal.go#L55: func (x *decimal) init(m nat, shift int) {
		decimal.go#L72: 		m = nat(nil).shr(m, s)
		decimal.go#L78: 		m = nat(nil).shl(m, uint(shift))
		float.go#L71: 	mant nat
		float.go#L582: func fnorm(m nat) int64 {
		float.go#L695: func msb32(x nat) uint32 {
		float.go#L713: func msb64(x nat) uint64 {
		float.go#L1237: 			t := nat(nil).shl(y.mant, uint(ey-ex))
		float.go#L1248: 			t := nat(nil).shl(x.mant, uint(ex-ey))
		float.go#L1282: 			t := nat(nil).shl(y.mant, uint(ey-ex))
		float.go#L1293: 			t := nat(nil).shl(x.mant, uint(ex-ey))
		float.go#L1354: 		xadj = make(nat, len(x.mant)+d)
		float.go#L1366: 	var r nat
		ftoa.go#L186: 	mant := nat(nil).set(x.mant)
		ftoa.go#L200: 	var tmp nat
		ftoa.go#L332: 		m = nat(nil).shl(m, uint(x.prec-w))
		ftoa.go#L334: 		m = nat(nil).shr(m, uint(w-x.prec))
		ftoa.go#L383: 		m = nat(nil).shl(m, n-w)
		ftoa.go#L385: 		m = nat(nil).shr(m, w-n)
		int.go#L35: 	abs nat  // absolute value of the integer
		int.go#L121: 	z.abs = nat(abs).norm()
		int.go#L276: 	_, z.abs = nat(nil).div(z.abs, x.abs, y.abs)
		int.go#L401: func low32(x nat) uint32 {
		int.go#L409: func low64(x nat) uint64 {
		int.go#L584: 	var mWords nat
		int.go#L925: func (z nat) modInverse(g, n nat) nat {
		int.go#L1142: 		t := nat(nil).sub(x.abs, natOne)
		int.go#L1175: 			x1 := nat(nil).sub(x.abs, natOne)
		int.go#L1176: 			y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1194: 	y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1205: 			x1 := nat(nil).sub(x.abs, natOne)
		int.go#L1206: 			y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1220: 		x1 := nat(nil).sub(x.abs, natOne)
		int.go#L1227: 	y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1238: 			x1 := nat(nil).sub(x.abs, natOne)
		int.go#L1239: 			y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1257: 	y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1268: 			x1 := nat(nil).sub(x.abs, natOne)
		int.go#L1269: 			y1 := nat(nil).sub(y.abs, natOne)
		int.go#L1287: 	y1 := nat(nil).sub(y.abs, natOne)
		nat.go#L34: type nat []Word
		nat.go#L37: 	natOne  = nat{1}
		nat.go#L38: 	natTwo  = nat{2}
		nat.go#L39: 	natFive = nat{5}
		nat.go#L40: 	natTen  = nat{10}
		nat.go#L43: func (z nat) String() string {
		nat.go#L47: func (z nat) norm() nat {
		nat.go#L55: func (z nat) make(n int) nat {
		nat.go#L61: 		return make(nat, 1)
		nat.go#L66: 	return make(nat, n, n+e)
		nat.go#L69: func (z nat) setWord(x Word) nat {
		nat.go#L78: func (z nat) setUint64(x uint64) nat {
		nat.go#L90: func (z nat) set(x nat) nat {
		nat.go#L96: func (z nat) add(x, y nat) nat {
		nat.go#L122: func (z nat) sub(x, y nat) nat {
		nat.go#L150: func (x nat) cmp(y nat) (r int) {
		nat.go#L177: func (z nat) mulAddWW(x nat, y, r Word) nat {
		nat.go#L192: func basicMul(z, x, y nat) {
		nat.go#L210: func (z nat) montgomery(x, y, m nat, k Word, n int) nat {
		nat.go#L245: func karatsubaAdd(z, x nat, n int) {
		nat.go#L252: func karatsubaSub(z, x nat, n int) {
		nat.go#L267: func karatsuba(z, x, y nat) {
		nat.go#L368: func alias(x, y nat) bool {
		nat.go#L375: func addAt(z, x nat, i int) {
		nat.go#L399: func (z nat) mul(x, y nat) nat {
		nat.go#L490: func basicSqr(z, x nat) {
		nat.go#L513: func karatsubaSqr(z, x nat) {
		nat.go#L551: func (z nat) sqr(x nat) nat {
		nat.go#L609: func (z nat) mulRange(a, b uint64) nat {
		nat.go#L619: 		return z.mul(nat(nil).setUint64(a), nat(nil).setUint64(b))
		nat.go#L622: 	return z.mul(nat(nil).mulRange(a, m), nat(nil).mulRange(m+1, b))
		nat.go#L627: func getNat(n int) *nat {
		nat.go#L628: 	var z *nat
		nat.go#L630: 		z = v.(*nat)
		nat.go#L633: 		z = new(nat)
		nat.go#L642: func putNat(x *nat) {
		nat.go#L650: func (x nat) bitLen() int {
		nat.go#L672: func (x nat) trailingZeroBits() uint {
		nat.go#L685: func (x nat) isPow2() (uint, bool) {
		nat.go#L696: func same(x, y nat) bool {
		nat.go#L701: func (z nat) shl(x nat, s uint) nat {
		nat.go#L726: func (z nat) shr(x nat, s uint) nat {
		nat.go#L749: func (z nat) setBit(x nat, i uint, b uint) nat {
		nat.go#L779: func (x nat) bit(i uint) uint {
		nat.go#L790: func (x nat) sticky(i uint) uint {
		nat.go#L810: func (z nat) and(x, y nat) nat {
		nat.go#L827: func (z nat) trunc(x nat, n uint) nat {
		nat.go#L840: func (z nat) andNot(x, y nat) nat {
		nat.go#L857: func (z nat) or(x, y nat) nat {
		nat.go#L876: func (z nat) xor(x, y nat) nat {
		nat.go#L897: func (z nat) random(rand *rand.Rand, limit nat, n int) nat {
		nat.go#L933: func (z nat) expNN(x, y, m nat, slow bool) nat {
		nat.go#L996: 	var q nat
		nat.go#L1007: 	var zz, r nat
		nat.go#L1057: func (z nat) expNNMontgomeryEven(x, y, m nat) nat {
		nat.go#L1060: 	m1 := nat(nil).shl(natOne, n)
		nat.go#L1061: 	m2 := nat(nil).shr(m, n)
		nat.go#L1069: 	z1 := nat(nil).expNN(x, y, m1, false)
		nat.go#L1070: 	z2 := nat(nil).expNN(x, y, m2, false)
		nat.go#L1088: 	m2inv := nat(nil).modInverse(m2, m1)
		nat.go#L1100: func (z nat) expNNWindowed(x, y nat, logM uint) nat {
		nat.go#L1121: 	var powers [1 << n]*nat
		nat.go#L1199: func (z nat) expNNMontgomery(x, y, m nat) nat {
		nat.go#L1205: 		_, x = nat(nil).div(nil, x, m)
		nat.go#L1209: 		rr := make(nat, numWords)
		nat.go#L1226: 	RR := nat(nil).setWord(1)
		nat.go#L1227: 	zz := nat(nil).shl(RR, uint(2*numWords*_W))
		nat.go#L1228: 	_, RR = nat(nil).div(RR, zz, m)
		nat.go#L1235: 	one := make(nat, numWords)
		nat.go#L1240: 	var powers [1 << n]nat
		nat.go#L1283: 			_, zz = nat(nil).div(nil, zz, m)
		nat.go#L1294: func (z nat) bytes(buf []byte) (i int) {
		nat.go#L1331: func (z nat) setBytes(buf []byte) nat {
		nat.go#L1352: func (z nat) sqrt(x nat) nat {
		nat.go#L1365: 	var z1, z2 nat
		nat.go#L1386: func (z nat) subMod2N(x, y nat, n uint) nat {
		nat.go#L1392: 			x = nat(nil).trunc(x, n)
		nat.go#L1400: 			y = nat(nil).trunc(y, n)
		natconv.go#L108: func (z nat) scan(r io.ByteScanner, base int, fracOk bool) (res nat, b, count int, err error) {
		natconv.go#L258: func (x nat) utoa(base int) []byte {
		natconv.go#L263: func (x nat) itoa(neg bool, base int) []byte {
		natconv.go#L331: 		q := nat(nil).set(x)
		natconv.go#L368: func (q nat) convertWords(s []byte, b Word, ndigits int, bb Word, table []divisor) {
		natconv.go#L372: 		var r nat
		natconv.go#L443: 	bbb     nat // divisor
		natconv.go#L454: func (z nat) expWW(x, y Word) nat {
		natconv.go#L455: 	return z.expNN(nat(nil).setWord(x), nat(nil).setWord(y), nil, false)
		natconv.go#L483: 		var larger nat
		natconv.go#L487: 					table[0].bbb = nat(nil).expWW(bb, Word(leafSize))
		natconv.go#L490: 					table[i].bbb = nat(nil).sqr(table[i-1].bbb)
		natconv.go#L495: 				larger = nat(nil).set(table[i].bbb)
		natdiv.go#L505: func (z nat) rem(u, v nat) (r nat) {
		natdiv.go#L518: func (z nat) div(z2, u, v nat) (q, r nat) {
		natdiv.go#L545: func (z nat) divW(x nat, y Word) (q nat, r Word) {
		natdiv.go#L565: func (x nat) modW(d Word) (r Word) {
		natdiv.go#L567: 	var q nat
		natdiv.go#L592: func (z nat) divLarge(u, uIn, vIn nat) (q, r nat) {
		natdiv.go#L634: func (q nat) divBasic(u, v nat) {
		natdiv.go#L729: func (z nat) divRecursive(u, v nat) {
		natdiv.go#L735: 	temps := make([]*nat, recDepth)
		natdiv.go#L754: func (z nat) divRecursiveStep(u, v nat, depth int, tmp *nat, temps []*nat) {
		prime.go#L86: func (n nat) probablyPrimeMillerRabin(reps int, force2 bool) bool {
		prime.go#L87: 	nm1 := nat(nil).sub(n, natOne)
		prime.go#L90: 	q := nat(nil).shr(nm1, k)
		prime.go#L92: 	nm3 := nat(nil).sub(nm1, natTwo)
		prime.go#L95: 	var x, y, quotient nat
		prime.go#L150: func (n nat) probablyPrimeLucas() bool {
		prime.go#L169: 	d := nat{1}
		prime.go#L170: 	t1 := nat(nil) // temp
		prime.go#L216: 	s := nat(nil).add(n, natOne)
		prime.go#L219: 	nm2 := nat(nil).sub(n, natTwo) // n-2
		prime.go#L249: 	natP := nat(nil).setWord(p)
		prime.go#L250: 	vk := nat(nil).setWord(2)
		prime.go#L251: 	vk1 := nat(nil).setWord(p)
		prime.go#L252: 	t2 := nat(nil) // temp
		rat.go#L77: func quotToFloat32(a, b nat) (f float32, exact bool) {
		rat.go#L111: 	var a2, b2 nat
		rat.go#L123: 	var q nat
		rat.go#L175: func quotToFloat64(a, b nat) (f float64, exact bool) {
		rat.go#L209: 	var a2, b2 nat
		rat.go#L221: 	var q nat
		rat.go#L310: 		babs = nat(nil).set(babs) // make a copy
		rat.go#L424: 		return &Int{abs: nat{1}}
		rat.go#L455: func mulDenom(z, x, y nat) nat {
		rat.go#L469: func (z *Int) scaleDenom(x *Int, f nat) {
		ratconv.go#L181: 		pow5 := z.b.abs.expNN(natFive, nat(nil).setWord(Word(n)), nil, false) // use underlying array of z.b.abs
		ratconv.go#L345: 	q, r := nat(nil).div(nat(nil), x.a.abs, x.b.abs)
		ratconv.go#L349: 		p = nat(nil).expNN(natTen, nat(nil).setUint64(uint64(prec)), nil, false)
		ratconv.go#L353: 	r, r2 := r.div(nat(nil), r, x.b.abs)
		ratconv.go#L360: 			q = nat(nil).add(q, natOne)
		ratconv.go#L361: 			r = nat(nil).sub(r, p)
		ratconv.go#L413: 	var q nat
		ratconv.go#L423: 	var tab []nat        // tab[i] == (5^fp)^(2^i) == 5^(fp·2^i)
		ratconv.go#L424: 	f := nat{1220703125} // == 5^fp (must fit into a uint32 Word)
		ratconv.go#L425: 	var t, r nat         // temporaries
		ratconv.go#L431: 		f = nat(nil).sqr(f) // nat(nil) to ensure a new f for each table entry